{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:14.641664400Z",
     "start_time": "2023-09-06T05:35:14.627549800Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05. Noisy Networks for Exploration\n",
    "\n",
    "[M. Fortunato et al., \"Noisy Networks for Exploration.\" arXiv preprint arXiv:1706.10295, 2017.](https://arxiv.org/pdf/1706.10295.pdf)\n",
    "\n",
    "\n",
    "NoisyNet is an exploration method that learns perturbations of the network weights to drive exploration. The key insight is that a single change to the weight vector can induce a consistent, and potentially very complex, state-dependent change in policy over multiple time steps.\n",
    "\n",
    "Firstly, let's take a look into a linear layer of a neural network with $p$ inputs and $q$ outputs, represented by\n",
    "\n",
    "$$\n",
    "y = wx + b,\n",
    "$$\n",
    "\n",
    "where $x \\in \\mathbb{R}^p$ is the layer input, $w \\in \\mathbb{R}^{q \\times p}$, and $b \\in \\mathbb{R}$ the bias.\n",
    "\n",
    "The corresponding noisy linear layer is defined as:\n",
    "\n",
    "$$\n",
    "y = (\\mu^w + \\sigma^w \\odot \\epsilon^w) x + \\mu^b + \\sigma^b \\odot \\epsilon^b,\n",
    "$$\n",
    "\n",
    "where $\\mu^w + \\sigma^w \\odot \\epsilon^w$ and $\\mu^b + \\sigma^b \\odot \\epsilon^b$ replace $w$ and $b$ in the first linear layer equation. The parameters $\\mu^w \\in \\mathbb{R}^{q \\times p}, \\mu^b \\in \\mathbb{R}^q, \\sigma^w \\in \\mathbb{R}^{q \\times p}$ and $\\sigma^b \\in \\mathbb{R}^q$ are learnable, whereas $\\epsilon^w \\in \\mathbb{R}^{q \\times p}$ and $\\epsilon^b \\in \\mathbb{R}^q$ are noise random variables which can be generated by one of the following two ways:\n",
    "\n",
    "1. **Independent Gaussian noise**: the noise applied to each weight and bias is independent, where each random noise entry is drawn from a unit Gaussian distribution. This means that for each noisy linear layer, there are $pq + q$ noise variables (for $p$ inputs to the layer and $q$ outputs).\n",
    "2. **Factorised Gaussian noise:** This is a more computationally efficient way. It produces 2 random Gaussian noise vectors ($p, q$) and makes $pq + q$ noise entries by outer product as follows:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\epsilon_{i,j}^w &= f(\\epsilon_i) f(\\epsilon_j),\\\\\n",
    "\\epsilon_{j}^b &= f(\\epsilon_i),\\\\\n",
    "\\text{where } f(x) &= sgn(x) \\sqrt{|x|}.\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "In all experiements of the paper, the authors used Factorised Gaussian noise, so we will go for it as well.\n",
    "\n",
    "主要是对神经网络的优化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.097263600Z",
     "start_time": "2023-09-06T05:35:14.642622100Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.115296800Z",
     "start_time": "2023-09-06T05:35:16.100262900Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noisy Layer\n",
    "\n",
    "**References:**\n",
    "- https://github.com/higgsfield/RL-Adventure/blob/master/5.noisy%20dqn.ipynb\n",
    "- https://github.com/Kaixhin/Rainbow/blob/master/model.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.156263Z",
     "start_time": "2023-09-06T05:35:16.117263300Z"
    }
   },
   "outputs": [],
   "source": [
    "class NoisyLinear(nn.Module):\n",
    "    \"\"\"Noisy linear module for NoisyNet.\n",
    "    \n",
    "    Attributes:\n",
    "        in_features (int): input size of linear module\n",
    "        out_features (int): output size of linear module\n",
    "        std_init (float): initial std value\n",
    "        weight_mu (nn.Parameter): mean value weight parameter\n",
    "        weight_sigma (nn.Parameter): std value weight parameter\n",
    "        bias_mu (nn.Parameter): mean value bias parameter\n",
    "        bias_sigma (nn.Parameter): std value bias parameter\n",
    "        \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, in_features: int, out_features: int, std_init: float = 0.5):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(NoisyLinear, self).__init__()\n",
    "        \n",
    "        self.in_features = in_features\n",
    "        self.out_features = out_features\n",
    "        self.std_init = std_init\n",
    "\n",
    "        self.weight_mu = nn.Parameter(torch.Tensor(out_features, in_features))\n",
    "        self.weight_sigma = nn.Parameter(\n",
    "            torch.Tensor(out_features, in_features)\n",
    "        )\n",
    "        self.register_buffer(\n",
    "            \"weight_epsilon\", torch.Tensor(out_features, in_features)\n",
    "        )\n",
    "\n",
    "        self.bias_mu = nn.Parameter(torch.Tensor(out_features))\n",
    "        self.bias_sigma = nn.Parameter(torch.Tensor(out_features))\n",
    "        self.register_buffer(\"bias_epsilon\", torch.Tensor(out_features))\n",
    "\n",
    "        self.reset_parameters()\n",
    "        self.reset_noise()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        \"\"\"Reset trainable network parameters (factorized gaussian noise).\"\"\"\n",
    "        mu_range = 1 / math.sqrt(self.in_features)\n",
    "        self.weight_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.weight_sigma.data.fill_(\n",
    "            self.std_init / math.sqrt(self.in_features)\n",
    "        )\n",
    "        self.bias_mu.data.uniform_(-mu_range, mu_range)\n",
    "        self.bias_sigma.data.fill_(\n",
    "            self.std_init / math.sqrt(self.out_features)\n",
    "        )\n",
    "\n",
    "    def reset_noise(self):\n",
    "        \"\"\"Make new noise.\"\"\"\n",
    "        epsilon_in = self.scale_noise(self.in_features)\n",
    "        epsilon_out = self.scale_noise(self.out_features)\n",
    "\n",
    "        # outer product\n",
    "        self.weight_epsilon.copy_(epsilon_out.ger(epsilon_in))\n",
    "        self.bias_epsilon.copy_(epsilon_out)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\n",
    "        \n",
    "        We don't use separate statements on train / eval mode.\n",
    "        It doesn't show remarkable difference of performance.\n",
    "        \"\"\"\n",
    "        return F.linear(\n",
    "            x,\n",
    "            self.weight_mu + self.weight_sigma * self.weight_epsilon,\n",
    "            self.bias_mu + self.bias_sigma * self.bias_epsilon,\n",
    "        )\n",
    "    \n",
    "    @staticmethod\n",
    "    def scale_noise(size: int) -> torch.Tensor:\n",
    "        \"\"\"Set scale to make noise (factorized gaussian noise).\"\"\"\n",
    "        x = torch.randn(size)\n",
    "\n",
    "        return x.sign().mul(x.abs().sqrt())  # sgn(x) * sqrt(abs(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Noisy Network\n",
    "\n",
    "We use NoisyLinear for the last two FC layers, and there is a method to reset noise at every step.\n",
    "These are the only differences from the example of *01.dqn.ipynb*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.157306500Z",
     "start_time": "2023-09-06T05:35:16.128264500Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.feature = nn.Linear(in_dim, 128)\n",
    "        self.noisy_layer1 = NoisyLinear(128, 128)\n",
    "        self.noisy_layer2 = NoisyLinear(128, out_dim)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        feature = F.relu(self.feature(x))\n",
    "        hidden = F.relu(self.noisy_layer1(feature))\n",
    "        out = self.noisy_layer2(hidden)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "    def reset_noise(self):\n",
    "        \"\"\"Reset all noisy layers.\"\"\"\n",
    "        self.noisy_layer1.reset_noise()\n",
    "        self.noisy_layer2.reset_noise()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + NoisyNet Agent (w/o DuelingNet)\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "In the paper, NoisyNet is used as a component of the Dueling Network Architecture, which includes Double-DQN and Prioritized Experience Replay. However, we don't implement them to simplify the tutorial. One thing to note is that NoisyNet is an alternertive to $\\epsilon$-greedy method, so all $\\epsilon$ related lines are removed. Please check all comments with *NoisyNet*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.177263300Z",
     "start_time": "2023-09-06T05:35:16.154264700Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        seed: int,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        # NoisyNet: All attributes related to epsilon are removed\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.target_update = target_update\n",
    "        self.seed = seed\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # NoisyNet: no epsilon greedy action selection\n",
    "        selected_action = self.dqn(\n",
    "            torch.FloatTensor(state).to(self.device)\n",
    "        ).argmax()\n",
    "        selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # NoisyNet: reset noise\n",
    "        self.dqn.reset_noise()\n",
    "        self.dqn_target.reset_noise()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # NoisyNet: removed decrease of epsilon\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.209264Z",
     "start_time": "2023-09-06T05:35:16.175267500Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:16.210263500Z",
     "start_time": "2023-09-06T05:35:16.191264200Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:35:17.313197600Z",
     "start_time": "2023-09-06T05:35:16.205314300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 256\n",
    "target_update = 150\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:36:09.092068Z",
     "start_time": "2023-09-06T05:36:08.034827800Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\noisy_net\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\noisy_net\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\noisy_net\\rl-video-episode-0.mp4\n",
      "score:  124.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/noisy_net\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:36:09.133067400Z",
     "start_time": "2023-09-06T05:36:09.087066900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAJgttZGF0AAACoQYF//+d3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMTkgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMgbWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz0xMiBsb29rYWhlYWRfdGhyZWFkcz0yIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFjZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTMgYl9weXJhbWlkPTIgYl9hZGFwdD0xIGJfYmlhcz0wIGRpcmVjdD0xIHdlaWdodGI9MSBvcGVuX2dvcD0wIHdlaWdodHA9MiBrZXlpbnQ9MjUwIGtleWludF9taW49MjUgc2NlbmVjdXQ9NDAgaW50cmFfcmVmcmVzaD0wIHJjX2xvb2thaGVhZD00MCByYz1jcmYgbWJ0cmVlPTEgY3JmPTIzLjAgcWNvbXA9MC42MCBxcG1pbj0wIHFwbWF4PTY5IHFwc3RlcD00IGlwX3JhdGlvPTEuNDAgYXE9MToxLjAwAIAAAAGzZYiEACf//vWxfApqyfOKDOgyLuGXJMmutiLibQDAACUoUAAAAwASyZQlsyAcmXdAAAATIAOKH0GUHmImKsVAleIOBmriAIZ18dBZOSkgF1OQnZD7SasHuXKmlleY5BpTn7cESBc+TerXajj5BgaU89FsUa70F3jaVhNvgnXgcDz7mq8sF4Y0MBHKQ4NoQXm9bZRc5dO2speKWm4DnxQB7b6WfT1sP839N9B/ijdJwAAQeWlzuVM5oFdbmw+KrB2CyHaWUe8Ay+CDcuu5b7cVu9+HLC/3BtKzRjaFbZilRJffNTwMx8DHhAliCt7+xOYQdbFnuCm4YWWs8NeAa49svX58hl/u3RUW5RftKx1zVrJyM1cQRf63IBlI0ik+1jnmpome/wrf/5C0A5CqsxwgLMkVENIsK24mB221cCUfdYIMqv8hFnyOkqnJJBgpEDXK662Zz14wRTkwCSgDhMMS3lUQsQSrU0t3AA+u/BwKCxH95og/Sm90UyppjNz7MqG18EOe5c3/pFugTMM3dr/p9Q9sdohEeR/p7Nra5oRwJW66KCFwB31j9WPGAAADAAADAAKHAAAAikGaJGxCv/44QAAAJt/X+Fu7UQitfalsocn+HF4tFaNxDVerW6Y6t8B8PiZDSLiTKD9Bx176/UR7LGzPGXqpVYmI6Mmm4r9ahmytstLZFmRJyYmenEOKfr6CxW/WHKorKG3JwG9LQT+AEB23hIFVccXVmJrauNEsL19z+kFdcD+YLd9EHNH8zmmyiAAAACdBnkJ4hH8AAAMDNg/rRhKPEi0U1xgUb/1FF0t/j90DdgJQdZO7bRkAAAAXAZ5hdEf/AAADALWhQuu/Vi1jXPSVr/AAAAAnAZ5jakf/AAAFHTT14V9rLHxFyJmT3Rio7oPXNcKZOLb4tZh0ZcLNAAAAm0GaaEmoQWiZTAhP//3xAAADAqDV4r2vl1h4vAEaCk6ykKiVOlbnKIzQvu/URtL0t37J76jEjgOpEesBBAXMYf3xYsrCgUCbeqqYIDZmhUoL5W2sDUk9DVGg5r/YpQh9SHtD1yVoBOTW7ZCPxuTJZnpsk9q12VZSSQddkzZTkdzJ+VHRSrapHq7ReITrKLDZH/yhKQNu8lJfG5ipAAAAQUGehkURLCP/AAAWtSsnmPrQAKDQT0hwZFt0QCG8GjOH1RHNi3dLtgLEVTSeG8Q/m4kUjhX8IO+gD+oV5I/TA1BxAAAAHwGepXRH/wAAI6wKm2nso9ta37UViBLW6QnYLvKvtGEAAAAsAZ6nakf/AAADAeYr94GZFm71eXiAs7ZhQgdJwiJi+UTBo2hUOaImiHEnmCAAAACrQZqsSahBbJlMCE///fEAAAMCoLQ8cMiVAWMVJ7ufcHts4rse4AAsn1JSagjpz9iqt9wm6tsERV1NEo0PBWFAlPvqKHy2B7bqcL9wSbcjNDY1dawOtnQL6KZyS/QBvQXN3/OZuLygza8yMZzhOqPUSwVE8fbOcVf7UEzNJ4T5PXEtXlqyYQxBOxx8jNKLE6pKafoG+RPv2XcFfzNZIaWV5cJnu/8p0FBgBY0FAAAAREGeykUVLCP/AAAWu4p+WnmUGf7Oq+xESpOgkqXhI1Pbo7wy2nAZqxZWpRuaAAF1izRTvUNNrvLScHdoZVUkr4nMhoF3AAAAIwGe6XRH/wAAI6v4W3sR3opArc9NIb56GBx556ygT+OnxYVgAAAAGwGe62pH/wAAI78dI8JP3V8RMVI9THS0BOP6EAAAAD5BmvBJqEFsmUwIT//98QAAAwKicHO4mPYBvMAlXJbJdKQBetjE+mcB8sv9HIXosgDGiLtYUfTikJQihvdPaQAAADJBnw5FFSwj/wAAFrUrN2uYDyiiEdzPWTHNayXf+03TaAn46eABYP4PthzpuPhaTJQswQAAAB0Bny10R/8AACPDF2ippVPU+8IJjrAYLeA8nzanwQAAABgBny9qR/8AAAVDNQ2g08O5Tke6rG+X43oAAABKQZs0SahBbJlMCEf//eEAAAQZ4bMi9WeTAhMacjkY2QQjXPxza9fdCjLPDqgxBSILZCMSrr8iH1bMCezDHFC3hdpJoxbwanFwJYAAAAAxQZ9SRRUsI/8AABa8QGj5Td7g1JiuNauw6ombsNOPfpyqZbQD0TDeToP3FhkGGlIWYQAAABsBn3F0R/8AACKp6vjfUTjo++M9xv+JC3vb/BwAAAAcAZ9zakf/AAAjsisHEzjhqCbv+DtbMdZqUY7ZgAAAAGdBm3hJqEFsmUwIT//98QAAAwKeOdaixA8gCBi5a53ghe7uqPLJJtP6a0LACSCr5Dt2me37gOoyf9BuLu8u9yt+ocpxOk/bwJ/9+Xgo6Qt0Z4XSqmu3eiwqS13y/XIb0FOe80VsMISxAAAAMUGflkUVLCP/AAAWu4p+XE86T9sqVMKXXzS/oXf9HN9aqr0de+bdMMLCmmAumfsDwYAAAAAnAZ+1dEf/AAAjwxdqNjmCBNd1qlSDuHx4GjRmwRGQUHgHiw6sYO23AAAAJgGft2pH/wAAI7I7xvGXbTj34lU8qdeYa6u8Ih2F9Ix+rDSRK5JhAAAAeEGbvEmoQWyZTAhH//3hAAAEE1v14Bx7QwRho++pflMkeQiGuIA7DRh05g9qZeLyEkQGyou5l+moeZ37fi2v9maIqV2Njsl7ze3ExGc2cDl10DRRXPrUX41W+wrrqtlgvm/EQ+vz94s5drk1ulT4cybjeOxR+NQRGAAAACJBn9pFFSwj/wAAFrNIi98q6tjAHocA9fzdzgA/2vUrrSSZAAAAJgGf+XRH/wAAI6w6zpFjxHET7i9KDZW1gABc2ynC3/T/OPgZXtmAAAAAJgGf+2pH/wAAI78a+QuiWDnNO4yO2V3g4agPl0ZfdsvMwBV2btuBAAAAdEGb4EmoQWyZTAhH//3hAAAEE1vSUeMmdlihHJK7dx1aXLBmPB8iPujaWlvOxDzt3GsV8yRoAL0OXHn3eMAQOTLwV+WeSkT+v5VjylgbiHEAaG4+8C05x3RIgmRVC8ZTJsLhMBcnzIvCwzITdbzq2gWKNUFJAAAAKkGeHkUVLCP/AAAWs0iL3ysnnEEJN6BGTACsX7RPwwolSHHBU6F34eQOSAAAACcBnj10R/8AACPDPpPI7Z2CvRxUuAKZNACSy1mObbbeafr0I4ZWZJMAAAAaAZ4/akf/AAAjsisHdyBL8X6iMlyKGWJULbkAAABvQZokSahBbJlMCEf//eEAAAQzP4/dGCgIgDFd33kpxwQjaEJ1tbGRXO/+FiEPlD5J6C8gXPeR7/FmH3kNE8t7Da/CIBPZ03Dxj+kA+4wPN9t1uxlbhpPCsNKe3eHJTjNKAxR2+SCtqa6VwXgq7fvAAAAAMUGeQkUVLCP/AAAXQ0e3DcE0AQg+VHzGoxP/tJh9XUQ22iLhDqsgQOCyvMn65KYFBbkAAAAlAZ5hdEf/AAAkwJkfzsww9VL9gnPYZrbNCPf1wioTdvS737qolQAAAC0BnmNqR/8AACS/BCcSyWmauFZTIzqn30IX+cGjuuAB/xzzlLHnwhxvHGD+NmEAAABNQZpoSahBbJlMCEf//eEAAAQzP7awFaqQB/705RmMMJFLtrJ7iRE8uT/7oBtB5SfbCBM/o14ADI/777QU4t6UtrnnXUs019eLQ4/5GTsAAABJQZ6GRRUsI/8AABdDR/kLkOFlYS5mZBDl9R9m0dlxBHKVEsl208GTnz3pXpxAgFUWDQvZgZZCBHegwALYO3KDfNYjFvBwiEQSYQAAACYBnqV0R/8AACTAmd3pXpFlEfqB0DMW58/tg4fPl6dp2NG2p7dUqQAAACABnqdqR/8AACS/BCWSJMg487ItXjFZpoH5y+w+GvQSYAAAAGBBmqxJqEFsmUwIR//94QAABDNIMt/pWQoRqoqzVuMm2zlQB4jTRL7touTOx6oiMmvtZLAp/GAgK/UU/kf9UUz6/T8Ua05fW4qwIMHCsR5fr0pISzI6mEgw8DxmIGXzE04AAAAlQZ7KRRUsI/8AABc0+tUQ0Zsr2PbMOVf5k9xSww09ReD2WNXa9wAAACABnul0R/8AACSp6lO7XKN1kvuoAZhDdUyBWUxLgBuPcAAAACkBnutqR/8AACS9gy7O5EpZmAAC50HEWBKAPZ0C7xKDpZwtlLW+11Xa8AAAAFhBmvBJqEFsmUwIR//94QAABDnCfsz/KcDAVs0ADhfK0qPkiPQT97dCcnttajwHkjZBdXg+OB2v0AFbtnuv8Az5AhWaEj03KvvTAcd4PD6HmE9EOeNRQbshAAAALUGfDkUVLCP/AAAXS1tmBl+hSDAIABEQi3kEaJ12gS4g7YGpt0IhkO83NZFa8QAAACABny10R/8AACTAmd7ITpy0YkLJhXKdcomXD8rCOgvvcQAAACUBny9qR/8AACSyLTZG9hjp+eBs+TisgyyXpEtRWaGd3qfjIB7gAAAAXEGbNEmoQWyZTAhH//3hAAAEVLYDIbu5apniPSDXZPjSJIrLf7RqgiI3ztUMTcDgd7IOeXmiaShGiaN+5DRKA2M2z+k2EuxHSkrVn/3PeARW85aqTUdw4oPdD4RAAAAAPkGfUkUVLCP/AAAX6YLtsAaZ+hJVvqO2I5s2Wd3aIJ8gML0dUUXDBpAANzysUOhdGG/wC+PTAIUDZIcwKnXhAAAAIAGfcXRH/wAAJKw6BiSApHF0LpEBAjPMrgk2z0ua+6l4AAAALgGfc2pH/wAAJb70cQ1Zu3lRzjHUzp/CD1sO0di8RWpSIL4gAhWPcKRvP0cpakAAAABaQZt4SahBbJlMCEf//eEAAARTSDLf6VkRjdxfHJppH/SlLQJEFe+fr+86wC7ZPYXVteqI47RtvZsm40WhUZuWCKLoNrtGNTc1mL+7dRpWUP+0lpTNtHkINcyzAAAANkGflkUVLCP/AAAX3+votEjz4cIlw8JCSB5clUTSAAiHR3NcszsAwKPheS3RWRcXg+lZRyMjYAAAAC0Bn7V0R/8AACXAmd3pXpFlEfqB0wjcPHzPgyiRzYCZtHWOmH1sbYLVKySEUkEAAAAtAZ+3akf/AAAlrl4zgi+0F8c/W2+IAW5+qGjQnphkOuBjowF/seStGwgFzb7hAAAAjEGbvEmoQWyZTAhP//3xAAADAsSnpjdcQKyOsKfhcKZHqgRfQ24Bvjyu5lulV6HO8b6/ADQHcJtzY1G7cM3dvhTbr87i4iZP6TTacZdUMdC1O/iwzg9tOatOxyfGCLRJVji6Gg4qmkErmAZMIGbqLXRTab/ghnMTynB+FCDvW3RRh1OXiDdIOCZjpVVAAAAAPUGf2kUVLCP/AAAX6GMr/yYgwRHyEjUemZ3e9rTJuX9CblDYkioFFaz5DSTveOV70kf1A6mGJ6vR0wHldYEAAAAxAZ/5dEf/AAAlv+/bqOJCpim53Mw9Tg1TEEvGSvP67jwAsWBQT6h8F77dso3qhkR04AAAACgBn/tqR/8AACWtXA6PMz6nyb4ktAFVzu3jU6mR+qXH6hImscX0qyDBAAAAWEGb4EmoQWyZTAhP//3xAAADAtTvCK/ixrfYgjThKvWWKQCU235T4JY1bSO+5qnIFchDBxYkQDGc+OcTGIh+tnN8HfPOqHAVh1P24jifhDpL9IHjifbuoEEAAABBQZ4eRRUsI/8AABiJgu2wBB1ynB8IpHsyXwT+gBOMY5BPXK6OUzoaGQGhRC52n54vUH80RGRqeenf8BI75alPnusAAAArAZ49dEf/AAAlt6F5GmPj9x4mwAZBWIWzQ5VlFENIloYHYoqAIhcb8dqt3AAAADYBnj9qR/8AACa+9T4ahZbAHnRkL5FqeaJFLlNVNnnJgA5o1FoiVDwAyp9m+sncpZrsqBVy2fEAAACTQZokSahBbJlMCEf//eEAAARzUDS/eJWQy5wCZ9aZ/WiuZRG3y/iY+cuv7Qq7RQEVOvXV2RTzd81UN8EhLGD3HYVlwIUlrFvgYtK9rfIec7olP8BeBP1SB5CNIyT6ukxGH7EZB+wd/BaDQzGtZGKrITxuc5ZZVGwKYdqsvg/ZbHMOzwi4FGesn/G2TB/C1DCSigw4AAAARkGeQkUVLCP/AAAYf3UgO+UpiFPD1DFC/hJHZPRXAsikwIsO9q8LgptX1s+QMEgdkseZJV6J1hv7LxAAOEUZyRzCPzqzQIEAAAAxAZ5hdEf/AAAmv+/bqRSm41z/ZTnTfF8EazAALYw0DqwV41mjWYOlAg8w9qRz0KltOAAAADcBnmNqR/8AACatW2Zw+mS400gmPw8tTTRymngjllatU1CLxfm+u0CI3OUZlvh5neJzQxK/moclAAAAp0GaaEmoQWyZTAhH//3hAAAEc1A46GBoNtJciovbELlAlXu3ZgEIu7al/WwdBG33Pw+14Ylz5KCbZRC0v1+NSjVlj6QaPG1O6Xd9KAUTlG4Ot8Lcs+QOBPiCufTHkWbAjmWOyP5FvirlqHOBuKyBJaGsjYmQxnFrRfQAccqy6H3T0/sOXaup/9ohfY9rGP7iHfnQU8GLcRIB9cvi3TpN72+kmqI8mBmDAAAAOkGehkUVLCP/AAAYf3Udah+bEmb+XPzrTIhtb7H/iqC3FoMkh+KFGjTwrYxQuMsdrhK/yHUvL0cC3tEAAAAwAZ6ldEf/AAAmv+/bqOJpG2acAa6qAUg6GTBURrJb50e68AJpgCfmWomo5AuZUM+BAAAALQGep2pH/wAAJr0moTb073h3CxTkQuRkmXbFxIFxzhnlk+eaOTNjzz+pvH7uEAAAAKRBmqxJqEFsmUwIR//94QAABJNSlvpIBZ92nNRWTrXcZGYIIg4/wcbyQy9e19moVyIXBuZu4S/kV/MqqvxuLhClnVY/j10TZs72tPPCc9VfdOvWfdoyEJS1aRMPK243VVuEw7Rvrwlgd5MSjx9dRruNGUdYt1uKLS/RdHH2l/MCtIwODKHjljnsr9nmTeLHuBBpnhLjJH47M3UvtpcwO4VfVcTM+AAAAEdBnspFFSwj/wAAGR91NN7mzYXNmEUAOsXEQS5f4SP9ouOP9vh8puq+i/IpX8LK3nRUmow42CmvLPyb6VNKz01hKNdeFiPu6QAAAC8Bnul0R/8AACfanY6B5h47EHemw9hgW1nUrQlRf5p5aou9WQKYhex73481/5p7KgAAAC4BnutqR/8AACfEGZfJGJyEMVY2hYiErovlZ0CmM3fBtXCOSriJT4/p5X2+1Ec+AAAAfEGa7kmoQWyZTBRMI//94QAABJY9MAbYsOugmLbp4TpdiYBkBYPWwDHhT0ObO930KDQexWBM4cyEUV5pP6VcAblBIZ/z+LrflyPagzEkUm6ovVktdKohl5+dOR9LRv+mkL6Iot5SZfPSgu8EREoQms1MmAUu4LBnjbf+woEAAAAtAZ8Nakf/AAAn1zLZtKDOFS+PpGvFQs4R2JoIOECFwFK4HZ00CuZRAQYn2j3BAAAAbkGbEEnhClJlMFLCP/3hAAAEmCI/2fZVtcAGyJoKqjB82ijzzwlNZOue6hnpBpyYY33BXlfDXnWQR1bm1a4LnW/2c8k1JqBmer5EjyDcV/uXqZEbRdmQbGRATJN0zaJWaY8Hq+tI+wH8QjOT7mxBAAAALAGfL2pH/wAAKPls+66S0c5FMYlxZLfanL5ODmEnDhDJsnEdMFO1MNJZaz9wAAAAekGbNEnhDomUwIR//eEAAASzU9M2fHlHCcSXgVfUEaxj3cOhxczZh58Inbd8zQBn+7YtJ1V95xHYnwLkJF/6Q+ASwSusBKzvUJclutdxHGt9zAQPuuZ92xqcwO9vqPCVgi8P1YB/aTrqf2UZbZhQXGbKfpHwMwv7YyBIAAAAPkGfUkUVPCP/AAAZv4WvQtBaP78dTMWnGk/DnAK9LOSj115dnopuWIz4jNxXlyUzpWLRGP7gumSI7gkWva1RAAAAKgGfcXRH/wAAKPqdjWIdnFzfz2OX+C/sGvBvnTIKvzyiKeFQSSbHeCeacAAAACcBn3NqR/8AACjinJ/0lQMhYR5yCYGxZZ0LKqlUXVQiFIMQQVQKfYsAAABHQZt2SahBaJlMFPCP/eEAAASzS+jod3tjwVuX6dUMymT9CxvlQyL025UmVwC9egGJJCY72Tw7XYA1BOt5Vol7dVXEovendoEAAAAlAZ+Vakf/AAAo9zMnQ6HR9g6lQcPjI8XYBnooGULQAlM84nTsWAAAAFJBm5pJ4QpSZTAj//yEAAAS0bjSewUVHXRicRZS0Zj/QOh1bZsQHHTJdb3dAxE5KunemUiJT1TMmEb+AAxcq41jCaYdvdt5DWTluQX8cMjNXvohAAAAJUGfuEU0TCP/AAAaX5IHQteaeC/DIXlDNsrmZcD8LIn/Fhh017cAAAAoAZ/XdEf/AAAp/56S7uzMb4CS/nQeerAP9kNryhVIOnEDyCaxinaUBgAAACQBn9lqR/8AACoCnJ/0hj81X8QrAQEiLasQoMkHBxW7i+C8z4EAAAB1QZvbSahBaJlMCEf//eEAAATWONzWRLAEIwopcJqMXIyVlnGkIRj2/SYSMgxCvWU409TUeJyFEKUsmYSCh5wu+eObkTG1SpKm+Bkz+mnNnTuwWwF7phGfAo4Tc+xN47XGdELXMXGrC/p8YRMd+glwGuHWcGkQAAAAckGb/knhClJlMCEf/eEAAAT1k0k2Vfh+0Bs+GOpdegC/VaqGcUBc6/dl6ivMN5jJaJWw3H+8m0994SJIpPpyH4KbSz7/XLTQTP5/PAmkyOByGYmIYg0lnH1aTMWS+4dba+1urUiGad0FwdghD33L9SF1xQAAADFBnhxFNEwj/wAAGwmCv8o3Quloxsb10FhWTAvHzbGnwH3mUA2nh/6dOb3w3TKdMLlhAAAAIgGePWpH/wAAKyKc2NKXqHN2EczKFuhjjq1LM+feqrnqyNUAAABoQZoiSahBaJlMCEf//eEAAAUbpz7dGNr8nhpsxHod/OQJRrShxZn3Ka+GoqZwBQbYW4xE23fcOhzdI1vdlxCu1EH5jn1adnsXoZdggroQ2DO9OiLR2sIP+Jm9fVqqsufJWfmSuZkCv4AAAAAwQZ5ARREsI/8AABupgtctmggOvb07VyQXuEh/bqFAR2Uthys5dZcgo1c9gZZV8MuBAAAAJgGef3RH/wAAKzm16zSZpXPPoEi/U0T019/wQKZO/Y2QZtvS3eNOAAAAOAGeYWpH/wAALFmBEKFUB7jtTMfC+qIVjozWYntx3CcKth8w5CNrYABMuW/T+uxyE33PBqz/VZbBAAAAdEGaZEmoQWyZTBRMI//94QAABR1QiY3UAWGmcrV+m+pMyeoeg7cY0jxyr4Zn7hPef/BFTtZ9N95taR7PYQOaAH4qC1ahjjS09B6sI7D31bjEWn9cRfACjYK+eowLPxMyTXx9jfRJXgNYL3xAn0RsWWMP5NOPAAAALAGeg2pH/wAALFbBDJ8G3tQOEkem2+WnmK2AQ5Ti5VQldweSXDOyVSqBwVtBAAAAd0Gah0nhClJlMCEf/eEAAAU/Mg2zagDYYF3q4ZOH3RwyB/xxAN496MptLYKm8Wu9qLMPu8z2JPipNKJGpIOtZT8m4RSKMUQSySGbHsDbnERcmEPknQUxaq+IhXN36rnq4P+azcumjEIS+FoUwFUHlQnx+XPREs3BAAAAQUGepUU0TCP/AAAcWIGMtbNAMuffsHp9B1WOqwP4pOaQAJQs67THirVfn7dqbV3TS6tMT1UagEddfaD08riJ6KCBAAAAKQGexmpH/wAALXbBJgBY94s2wE5MtPhwbsJmULAs4aNcJlAxS2phMlSnAAAAQkGayUmoQWiZTBTwj/3hAAAFPZJg6GBmJ8qyANBCPru2uz7mpoL2W6oH4V7eXI/lyBpSuAKm1ceZVZ6Tkxx4WTgyzAAAACoBnuhqR/8AAC2DLpjPmWo6pt9euFDxr1+T6vAQc5u3mbvOI2w4fIe7GXAAAABNQZrsSeEKUmUwI//8hAAAFPTLYUE6HRjC4vWNRHUdTbl7YAMbkelpILV/cjOV4OL2sTM2N2TPk/l/NWolfMXguG+zIl3espY8EV94AGEAAAA1QZ8KRTRMI/8AAB0G93NJvH1q9OIReDEWe5o6LgmXFMvBbSxSAzIEZuWF84zLz6crlGGieqAAAAAmAZ8rakf/AAAugw4f9IXJfxNLcIAcVVSU8b5uPKc5owQQgJNRYv4AAABlQZstSahBaJlMCEf//eEAAAVhi+joYGc7FRMoT+DU2XwqPhb1MVonLFgphFO4rv5xKaDRT/QM0ait3YoADhAxyFnD99G6+VDqnz1yMJK8wHjbvZt5rLoXu9jb3erLKxXLcLA3lDkAAAB3QZtQSeEKUmUwIR/94QAABYlTz994NbwCZvBCyPfp0MMVNXk/fUABxM6RM/RIR/1ftO7JDtVfSjNre3HWd6Bhr0/azfb3mFXXdDjb6cQyBpvBuPXdJaCSvPK6qldIaDh41Ns7qwT7VuPSr/5Bo2+6LFrtL4ogAEEAAABHQZ9uRTRMI/8AAB22946VizixoXUkgX0ISYmQ1c6SdhPPu3w2k51paceuWIYp915/O5z+EJY5fnSiZ4ANUQ19mAoOHEG2aCEAAAAzAZ+Pakf/AAAvpn19xpqf2AYA+RgtUvY6YObTv1gmIzvC4zTiGEyP+8IFnF7zXBTPg1FOAAAAXEGbk0moQWiZTAj//IQAABYU0bFDZhdtcoHzo3FxpZHO4w/asq2Am6rmZqe1628SFlE6C1b5OPPjA6WhZVNnai5C3FTIsVin7m79IbCIRQjPXJa4O1rl35fZZHCAAAAANEGfsUURLH8AADD4PICC1nyUKsuIYIzMUKt63uXD5ivRCsq+LzQd7Ftt8HUsZnjySLsB/qcAAAAmAZ/Sakf/AAAw95629k5dIlIdclssdxjbU+iMNPzcXK/d9EDMN0AAAABHQZvUSahBbJlMCP/8hAAAFhSWv35T+zbUbvUARSLWy7/eaHZcPU2GgpBvoUHlnkpppkT1N8kIB54dQ8st1tE8pjxCfIMbw1IAAABIQZv1SeEKUmUwIR/94QAABc2L5Xr36UM2P8WD9wpI+FPLHpJXTI6zs212mIei+7IAp6wKxn3U2F/XhQHb/c4F+GzKRCT7CrthAAAAekGaF0nhDomUwU0TH//8hAAAFrSLC0AZflQW09fitE/fEUukxKKKBNL1rXFibdpSVsJYRFPn33VHpyiKJGcYtMtUgiSfVm5XTfWXIZld4+ALlE6F7d+UROzrruh1WUquZ/adj1g6OHiSmRK1CJuwoWhXd7qCH7GPXW3gAAAALwGeNmpH/wAAM5JRKFQ8jStBaQ65x6sbo4lW2AAFsgcnWC+Jr1EBI60HDBlrhU2fAAAAZkGaOEnhDyZTAhH//eEAAAX0Tg17u6jrVytj7qm+1QEaXPPt9FyTXCbEGy5oC8Uae4HQk90MV/Qp/fnraG7U0ZlvemXlW0kabXWywg/jxHeciKett0Ue9kWMBRje+tJeCjv/5hJ46wAAAHhBmlpJ4Q8mUwURPH/8hAAAFzTIicuaKhjaF/SS8rw/rZSmaH9gLRvitOrEqczEt+22L9dZ+SR0ICiN0y5xA9z/V3me4DdqtMAAKoqNMLNboCx5Pcb7XKVmQ2AV1Cp8whZivse+JTlAJtiXacgcfzGoVuxD9yx+oMAAAAA/AZ55akf/AAAzjshhDGog8sT18UrjFEdKePY+GDWEFDL43zjuGH0J7PFGOd187l9BuC8uixqB2EA3vRvGJOXBAAAAT0Gae0nhDyZTAhH//eEAAAYc/LwV/ck5Gd8HyeJUa3CZplN9vJ1HOEOLW+yaEuoE6/eAwT8XVHjP1IlLX1TZ1lQRehXWfj1pGxE7d5vrKgwAAABDQZqdSeEPJlMFETx//IQAABfP5mxPn9RGq4zAlyIiQC4rFGEehJ/FLdnckHEnWL4+lIU/zyqllk8pvzUxclA+I6NVgQAAACEBnrxqR/8AADS+2iWIXTFFIbEwPCsK4b5qxkxBulCwJuEAAAjLbW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAACdgAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAB/V0cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAACdgAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAlgAAAGQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAAnYAAACAAABAAAAAAdtbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAAyAAAAfgBVxAAAAAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAAHGG1pbmYAAAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAAAQAABthzdGJsAAAAmHN0c2QAAAAAAAAAAQAAAIhhdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAlgBkABIAAAASAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGP//AAAAMmF2Y0MBZAAf/+EAGWdkAB+s2UCYM+XhAAADAAEAAAMAZA8YMZYBAAZo6+PLIsAAAAAYc3R0cwAAAAAAAAABAAAAfgAAAQAAAAAUc3RzcwAAAAAAAAABAAAAAQAAA9BjdHRzAAAAAAAAAHgAAAABAAACAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAIAAAAAAQAABAAAAAACAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAQAAAAAAgAAAQAAAAABAAADAAAAAAEAAAEAAAAAAQAABAAAAAACAAABAAAAAAEAAAIAAAAAAQAABAAAAAACAAABAAAAAAEAAAQAAAAAAgAAAQAAAAACAAACAAAAAAEAAAMAAAAAAQAAAQAAAAABAAACAAAAAAEAAAMAAAAAAQAAAQAAAAABAAACAAAAAAEAAAMAAAAAAQAAAQAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAH4AAAABAAACDHN0c3oAAAAAAAAAAAAAAH4AAARcAAAAjgAAACsAAAAbAAAAKwAAAJ8AAABFAAAAIwAAADAAAACvAAAASAAAACcAAAAfAAAAQgAAADYAAAAhAAAAHAAAAE4AAAA1AAAAHwAAACAAAABrAAAANQAAACsAAAAqAAAAfAAAACYAAAAqAAAAKgAAAHgAAAAuAAAAKwAAAB4AAABzAAAANQAAACkAAAAxAAAAUQAAAE0AAAAqAAAAJAAAAGQAAAApAAAAJAAAAC0AAABcAAAAMQAAACQAAAApAAAAYAAAAEIAAAAkAAAAMgAAAF4AAAA6AAAAMQAAADEAAACQAAAAQQAAADUAAAAsAAAAXAAAAEUAAAAvAAAAOgAAAJcAAABKAAAANQAAADsAAACrAAAAPgAAADQAAAAxAAAAqAAAAEsAAAAzAAAAMgAAAIAAAAAxAAAAcgAAADAAAAB+AAAAQgAAAC4AAAArAAAASwAAACkAAABWAAAAKQAAACwAAAAoAAAAeQAAAHYAAAA1AAAAJgAAAGwAAAA0AAAAKgAAADwAAAB4AAAAMAAAAHsAAABFAAAALQAAAEYAAAAuAAAAUQAAADkAAAAqAAAAaQAAAHsAAABLAAAANwAAAGAAAAA4AAAAKgAAAEsAAABMAAAAfgAAADMAAABqAAAAfAAAAEMAAABTAAAARwAAACUAAAAUc3RjbwAAAAAAAAABAAAAMAAAAGJ1ZHRhAAAAWm1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTguMjkuMTAw\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/noisy_net\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
